"""
用户数据模型
"""

from typing import Dict, Any, Optional, List
from datetime import datetime, timedelta
from .base import BaseModel
import hashlib


class User(BaseModel):
    """用户模型类"""
    
    # 用户角色常量
    ROLE_GUEST = 'guest'
    ROLE_USER = 'user'
    ROLE_ADMIN = 'admin'
    
    # 用户状态常量
    STATUS_ACTIVE = 'active'
    STATUS_INACTIVE = 'inactive'
    STATUS_BANNED = 'banned'
    
    def __init__(self):
        super().__init__('users')
    
    def create_user(self, user_data: Dict[str, Any]) -> str:
        """
        创建新用户
        
        Args:
            user_data: 用户数据
            
        Returns:
            str: 用户ID
        """
        # 生成用户ID
        user_id = self.generate_id()
        
        # 构建用户记录
        user_record = {
            'user_id': user_id,
            'username': user_data.get('username'),
            'email': user_data.get('email'),
            'display_name': user_data.get('display_name', user_data.get('username')),
            'avatar_url': user_data.get('avatar_url'),
            'role': user_data.get('role', self.ROLE_GUEST),
            'status': user_data.get('status', self.STATUS_ACTIVE),
            'preferences': user_data.get('preferences', {}),
            'quota': user_data.get('quota', self._get_default_quota()),
            'usage_stats': {
                'total_tasks': 0,
                'completed_tasks': 0,
                'failed_tasks': 0,
                'total_file_size': 0,
                'last_activity': None
            },
            'metadata': user_data.get('metadata', {})
        }
        
        # 验证必填字段
        if not user_record['username'] and not user_record['email']:
            raise ValueError("用户名或邮箱至少需要提供一个")
        
        # 检查用户名或邮箱是否已存在
        if user_record['username'] and self.exists({'username': user_record['username']}):
            raise ValueError("用户名已存在")
        
        if user_record['email'] and self.exists({'email': user_record['email']}):
            raise ValueError("邮箱已存在")
        
        # 创建记录
        self.create(user_record)
        return user_id
    
    def get_user(self, user_id: str) -> Optional[Dict[str, Any]]:
        """
        获取用户信息
        
        Args:
            user_id: 用户ID
            
        Returns:
            Optional[Dict]: 用户信息或None
        """
        return self.find_one({'user_id': user_id})
    
    def get_user_by_username(self, username: str) -> Optional[Dict[str, Any]]:
        """
        根据用户名获取用户信息
        
        Args:
            username: 用户名
            
        Returns:
            Optional[Dict]: 用户信息或None
        """
        return self.find_one({'username': username})
    
    def get_user_by_email(self, email: str) -> Optional[Dict[str, Any]]:
        """
        根据邮箱获取用户信息
        
        Args:
            email: 邮箱地址
            
        Returns:
            Optional[Dict]: 用户信息或None
        """
        return self.find_one({'email': email})
    
    def update_user_preferences(self, user_id: str, preferences: Dict[str, Any]) -> bool:
        """
        更新用户偏好设置
        
        Args:
            user_id: 用户ID
            preferences: 偏好设置
            
        Returns:
            bool: 是否更新成功
        """
        return self.update_one(
            {'user_id': user_id},
            {'preferences': preferences}
        )
    
    def update_user_quota(self, user_id: str, quota: Dict[str, Any]) -> bool:
        """
        更新用户配额
        
        Args:
            user_id: 用户ID
            quota: 配额设置
            
        Returns:
            bool: 是否更新成功
        """
        return self.update_one(
            {'user_id': user_id},
            {'quota': quota}
        )
    
    def update_usage_stats(self, user_id: str, stats_update: Dict[str, Any]) -> bool:
        """
        更新用户使用统计
        
        Args:
            user_id: 用户ID
            stats_update: 统计更新数据
            
        Returns:
            bool: 是否更新成功
        """
        user = self.get_user(user_id)
        if not user:
            return False
        
        current_stats = user.get('usage_stats', {})
        
        # 更新统计数据
        for key, value in stats_update.items():
            if key in ['total_tasks', 'completed_tasks', 'failed_tasks', 'total_file_size']:
                current_stats[key] = current_stats.get(key, 0) + value
            else:
                current_stats[key] = value
        
        # 更新最后活动时间
        current_stats['last_activity'] = self.get_current_time()
        
        return self.update_one(
            {'user_id': user_id},
            {'usage_stats': current_stats}
        )
    
    def check_quota(self, user_id: str, file_size: int = 0) -> Dict[str, Any]:
        """
        检查用户配额
        
        Args:
            user_id: 用户ID
            file_size: 文件大小（字节）
            
        Returns:
            Dict: 配额检查结果
        """
        user = self.get_user(user_id)
        if not user:
            return {
                'allowed': False,
                'reason': '用户不存在'
            }
        
        quota = user.get('quota', {})
        usage_stats = user.get('usage_stats', {})
        
        # 检查每日任务限制
        daily_limit = quota.get('daily_tasks', 100)
        today_tasks = self._get_today_task_count(user_id)
        
        if today_tasks >= daily_limit:
            return {
                'allowed': False,
                'reason': f'已达到每日任务限制 ({daily_limit})'
            }
        
        # 检查文件大小限制
        max_file_size = quota.get('max_file_size', 16 * 1024 * 1024)  # 16MB
        if file_size > max_file_size:
            return {
                'allowed': False,
                'reason': f'文件大小超过限制 ({max_file_size / 1024 / 1024:.1f}MB)'
            }
        
        # 检查存储空间限制
        storage_limit = quota.get('storage_limit', 1024 * 1024 * 1024)  # 1GB
        current_usage = usage_stats.get('total_file_size', 0)
        
        if current_usage + file_size > storage_limit:
            return {
                'allowed': False,
                'reason': f'存储空间不足'
            }
        
        return {
            'allowed': True,
            'remaining_tasks': daily_limit - today_tasks,
            'remaining_storage': storage_limit - current_usage
        }
    
    def get_user_list(self, role: str = None, status: str = None, 
                     limit: int = 50, skip: int = 0) -> List[Dict[str, Any]]:
        """
        获取用户列表
        
        Args:
            role: 角色过滤（可选）
            status: 状态过滤（可选）
            limit: 限制数量
            skip: 跳过数量
            
        Returns:
            List[Dict]: 用户列表
        """
        query = {}
        
        if role:
            query['role'] = role
        
        if status:
            query['status'] = status
        
        return self.find_many(
            query=query,
            sort=[('created_at', -1)],
            limit=limit,
            skip=skip
        )
    
    def get_active_users(self, days: int = 30) -> List[Dict[str, Any]]:
        """
        获取活跃用户列表
        
        Args:
            days: 多少天内活跃
            
        Returns:
            List[Dict]: 活跃用户列表
        """
        cutoff_time = self.get_current_time() - timedelta(days=days)
        
        query = {
            'status': self.STATUS_ACTIVE,
            'usage_stats.last_activity': {'$gte': cutoff_time}
        }
        
        return self.find_many(
            query=query,
            sort=[('usage_stats.last_activity', -1)]
        )
    
    def ban_user(self, user_id: str, reason: str = None) -> bool:
        """
        封禁用户
        
        Args:
            user_id: 用户ID
            reason: 封禁原因
            
        Returns:
            bool: 是否操作成功
        """
        update_data = {
            'status': self.STATUS_BANNED,
            'ban_reason': reason,
            'banned_at': self.get_current_time()
        }
        
        return self.update_one({'user_id': user_id}, update_data)
    
    def unban_user(self, user_id: str) -> bool:
        """
        解封用户
        
        Args:
            user_id: 用户ID
            
        Returns:
            bool: 是否操作成功
        """
        update_data = {
            'status': self.STATUS_ACTIVE,
            'ban_reason': None,
            'banned_at': None,
            'unbanned_at': self.get_current_time()
        }
        
        return self.update_one({'user_id': user_id}, update_data)
    
    def delete_user(self, user_id: str) -> bool:
        """
        删除用户（软删除）
        
        Args:
            user_id: 用户ID
            
        Returns:
            bool: 是否删除成功
        """
        update_data = {
            'status': self.STATUS_INACTIVE,
            'deleted_at': self.get_current_time()
        }
        
        return self.update_one({'user_id': user_id}, update_data)
    
    def _get_default_quota(self) -> Dict[str, Any]:
        """
        获取默认配额设置
        
        Returns:
            Dict: 默认配额
        """
        return {
            'daily_tasks': 50,  # 每日任务限制
            'max_file_size': 16 * 1024 * 1024,  # 最大文件大小 16MB
            'storage_limit': 512 * 1024 * 1024,  # 存储限制 512MB
            'concurrent_tasks': 3,  # 并发任务限制
            'supported_formats': list(self.SUPPORTED_OUTPUT_FORMATS)
        }
    
    def _get_today_task_count(self, user_id: str) -> int:
        """
        获取用户今日任务数量
        
        Args:
            user_id: 用户ID
            
        Returns:
            int: 今日任务数量
        """
        from .task import Task
        
        # 获取今日开始时间
        today_start = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
        
        task_model = Task()
        query = {
            'user_id': user_id,
            'created_at': {'$gte': today_start}
        }
        
        return task_model.count(query)
    
    @property
    def SUPPORTED_OUTPUT_FORMATS(self):
        """支持的输出格式"""
        return {
            'docx', 'pdf', 'html', 'epub', 'odt', 'rtf', 'tex', 'pptx'
        }